// pages/roomSharingDetail/roomSharingDetail.js
const api = require("../../config/api.js");
const util = require("../../utils/util.js");
const shareCard = require("../../utils/shareCard.js");

Page({
  /**
   * 页面的初始数据
   */
  data: {
    // 拼房详情ID
    roomSharingId: null,
    // 当前登录用户信息
    currentUserInfo: null,
    // 用户信息
    userInfo: {
      nickName: "",
      imageUrl: "",
      skillIcons: [
        // 'https://static.codia.ai/image/2025-10-18/H7aWiQrJuy.png',
        // 'https://static.codia.ai/image/2025-10-18/e87WSdUDhD.png',
        // 'https://static.codia.ai/image/2025-10-18/RFYhV85GQm.png'
      ],
      badge: "https://static.codia.ai/image/2025-10-18/brc82VU2Ho.png"
    },
    // 拼房信息
    roomInfo: {
      type: "拼房",
      serviceType: "房找人",
      time: "后天 周六 10:00",
      address: "云顶大酒店",
      roomType: "标准间",
      sex: "不限",
      limitSex: "不限",
      price: "¥ 111/人",
      description: "寻找拼房伙伴，希望有共同爱好的朋友"
    },
    // 俱乐部信息
    clubInfo: {
      icon: "https://static.codia.ai/image/2025-10-18/bgQwsUMpWh.png",
      text: "俱乐部成员优先展示"
    },
    // 注意事项
    terms: `1. 添加联系人时，请备注“滑雪去”小程序，明确来意。
    2. 拼房约定达成后，需及时完成费用均摊，并提前沟通明确爽约处理规则，避免后续纠纷。
    3. 若拼房计划发生变动，务必立即联系对方，按照此前约定的规则协商处理。
    4. 住宿拼满且确认后，请及时下架相关拼房信息，防止因人员超额影响住宿安排。
    5.请遵守约定，避免爽约；若遭遇对方爽约，可联系管理员进行投诉，多次爽约者将被限制发布信息权限。`,
    // 风险须知
    riskNotice: {
      icon: "https://static.codia.ai/image/2025-10-18/L8TnoFZ3a8.png",
      text: "风险须知"
    },
    // 收藏状态
    isFavorited: false,
    // 风险须知弹窗显示状态
    showRiskNoticePopup: false,
    // 联系方式弹窗显示状态
    showContactPopup: false,
    // 原始房信息（包含联系方式）
    homeInfo: null,
    // 判断是否有经纬度信息，用于控制样式和点击事件
    hasLocation: false,
    // 分享卡片图片路径（缓存）
    shareCardImageUrl: ""
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad: function (options) {
    // 获取当前登录用户信息
    this.loadCurrentUserInfo();

    // 从页面参数获取拼房详情ID
    if (options.id) {
      this.setData({
        roomSharingId: options.id
      });
      this.loadRoomSharingDetail(options.id);
    }
  },

  /**
   * 加载当前登录用户信息
   */
  loadCurrentUserInfo: function () {
    const userInfo = wx.getStorageSync("userInfo");
    if (userInfo) {
      this.setData({
        currentUserInfo: userInfo
      });
    }
  },

  /**
   * 计算时间间隔（从 home.js 复制）
   */
  calculateDuration: function (beginTime, endTime) {
    if (!beginTime || !endTime) {
      return ""; // 如果没有时间信息，返回空字符串
    }

    try {
      let begin, end;

      // 处理开始时间
      if (typeof beginTime === "string" && beginTime.includes("-")) {
        // 日期字符串格式，如 "2024-12-22"
        begin = new Date(beginTime);
      } else {
        // 时间戳格式（可能是秒级或毫秒级）
        const beginTimestamp =
          typeof beginTime === "string" ? parseFloat(beginTime) : beginTime;
        begin =
          beginTimestamp < 10000000000
            ? new Date(beginTimestamp * 1000)
            : new Date(beginTimestamp);
      }

      // 处理结束时间
      if (typeof endTime === "string" && endTime.includes("-")) {
        // 日期字符串格式，如 "2024-12-22"
        end = new Date(endTime);
      } else {
        // 时间戳格式（可能是秒级或毫秒级）
        const endTimestamp =
          typeof endTime === "string" ? parseFloat(endTime) : endTime;
        end =
          endTimestamp < 10000000000
            ? new Date(endTimestamp * 1000)
            : new Date(endTimestamp);
      }

      // 验证日期是否有效
      if (isNaN(begin.getTime()) || isNaN(end.getTime())) {
        console.warn("无效的日期:", beginTime, endTime);
        return "";
      }

      // 计算日期差（按天计算，不考虑具体时间）
      const beginDate = new Date(
        begin.getFullYear(),
        begin.getMonth(),
        begin.getDate()
      );
      const endDate = new Date(
        end.getFullYear(),
        end.getMonth(),
        end.getDate()
      );
      const diffTime = endDate.getTime() - beginDate.getTime();
      const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));

      if (diffDays <= 0) {
        return "";
      }

      return `| ${diffDays}晚`;
    } catch (error) {
      console.error("计算住宿天数失败:", error);
      return "";
    }
  },

  /**
   * 格式化时间戳为可读日期
   */
  formatDate: function (timestamp) {
    if (!timestamp) return "时间待定";

    try {
      // 判断是秒级时间戳还是毫秒级时间戳
      const date =
        timestamp < 10000000000
          ? new Date(timestamp * 1000)
          : new Date(timestamp);

      // 验证日期是否有效
      if (isNaN(date.getTime())) {
        return "时间待定";
      }

      const now = new Date();
      const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
      const tomorrow = new Date(today.getTime() + 24 * 60 * 60 * 1000);
      const dayAfterTomorrow = new Date(
        today.getTime() + 2 * 24 * 60 * 60 * 1000
      );

      const targetDate = new Date(
        date.getFullYear(),
        date.getMonth(),
        date.getDate()
      );
      const month = date.getMonth() + 1;
      const day = date.getDate();
      const dayNames = ["周日", "周一", "周二", "周三", "周四", "周五", "周六"];
      const dayName = dayNames[date.getDay()];
      return `${month}.${day} ${dayName}`;
    } catch (error) {
      console.error("时间格式化失败:", error);
      return "时间待定";
    }
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady: function () {},

  /**
   * 生命周期函数--监听页面显示
   */
  onShow: function () {},

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide: function () {},

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload: function () {},

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh: function () {},

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom: function () {},

  /**
   * 生成分享卡片（预生成并缓存）
   */
  generateShareCard: function () {
    const that = this;
    const { roomInfo, roomSharingId } = this.data;

    if (!roomInfo || !roomSharingId) {
      return Promise.resolve();
    }

    // 异步生成分享卡片
    return shareCard
      .getShareCard("room", {
        id: roomSharingId,
        roomSharingId: roomSharingId,
        roomInfo: roomInfo
      })
      .then((shareConfig) => {
        // 缓存分享卡片图片路径
        that.setData({
          shareCardImageUrl: shareConfig.imageUrl
        });
        // 返回分享配置，供调用方使用
        return shareConfig;
      })
      .catch((err) => {
        console.error("生成分享卡片失败:", err);
        // 失败时使用基础图
        const fallbackConfig = {
          imageUrl: "/static/images/shareBase.png"
        };
        that.setData({
          shareCardImageUrl: fallbackConfig.imageUrl
        });
        return fallbackConfig;
      });
  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage: async function () {
    const { roomInfo, roomSharingId, shareCardImageUrl } = this.data;

    // 获取分享配置
    const shareConfig = shareCard.getShareConfig("room", {
      id: roomSharingId,
      roomSharingId: roomSharingId,
      roomInfo: roomInfo
    });

    // 如果没有缓存的分享卡片，显示loading并同步等待生成完成
    if (!shareCardImageUrl) {
      wx.showLoading({
        title: '生成分享卡片中...',
        mask: true
      });
      try {
        // 同步等待分享卡片生成完成，并获取返回的分享配置
        const generatedConfig = await this.generateShareCard();
        // 使用生成的分享卡片图片
        shareConfig.imageUrl = generatedConfig?.imageUrl || "/static/images/shareBase.png";
      } catch (err) {
        console.error('生成分享卡片失败:', err);
        shareConfig.imageUrl = "/static/images/shareBase.png";
      } finally {
        wx.hideLoading();
      }
    } else {
      // 使用缓存的分享卡片图片
      shareConfig.imageUrl = shareCardImageUrl;
    }

    return shareConfig;
  },

  /**
   * 返回上一页
   */
  goBack: function () {
    wx.navigateBack({
      delta: 1
    });
  },

  /**
   * 加入俱乐部
   */
  joinClub: function () {
    wx.navigateTo({
      url: "/pages/clubJoin/clubJoin",
      success: function () {
        console.log("跳转到加入俱乐部页面成功");
      },
      fail: function (err) {
        console.error("跳转到加入俱乐部页面失败:", err);
        wx.showToast({
          title: "页面跳转失败",
          icon: "none"
        });
      }
    });
  },

  /**
   * 收藏/取消收藏
   */
  toggleFavorite: function () {
    const that = this;
    const roomSharingId = this.data.roomSharingId;

    if (!roomSharingId) {
      wx.showToast({
        title: "数据错误",
        icon: "none"
      });
      return;
    }

    const isFavorited = !this.data.isFavorited;

    // 调用收藏API
    util
      .request(
        api.UserSave,
        {
          id: parseInt(roomSharingId),
          type: 1 // 0:拼车 1:拼房 2:雪票
        },
        "POST",
        "application/json"
      )
      .then((res) => {
        console.log("收藏API响应:", res);

        const normalizedRes = util.normalizeApiResponse(res);

        if (normalizedRes.success) {
          that.setData({
            isFavorited: isFavorited
          });

          wx.showToast({
            title: isFavorited ? "已收藏" : "已取消收藏",
            icon: "success"
          });

          // 重新加载详情数据以获取最新的收藏状态
          that.loadRoomSharingDetail(roomSharingId);
        } else {
          wx.showToast({
            title: normalizedRes.message || "操作失败",
            icon: "none"
          });
        }
      })
      .catch((err) => {
        console.error("收藏API请求失败:", err);
        wx.showToast({
          title: "网络错误，请重试",
          icon: "none"
        });
      });
  },

  /**
   * 显示联系方式弹窗（带登录校验）
   */
  showContactPopup: function () {
    const util = require("../../utils/util.js");

    // 检查是否已登录
    if (!util.checkUserLogin()) {
      util.showLoginModal("此操作需要先登录，是否立即登录？", () => {
        util.navigateToLogin();
      });
      return;
    }

    this.setData({
      showContactPopup: true
    });
  },

  /**
   * 关闭联系方式弹窗
   */
  closeContactPopup: function () {
    this.setData({
      showContactPopup: false
    });
  },

  /**
   * 阻止事件冒泡
   */
  stopPropagation: function () {
    // 阻止弹窗内容区域的点击事件冒泡
  },

  /**
   * 复制微信号
   */
  copyWechat: function () {
    const homeInfo = this.data.homeInfo;

    if (!homeInfo || !homeInfo.wechat) {
      wx.showToast({
        title: "暂无微信号",
        icon: "none"
      });
      return;
    }

    // 确保微信号是字符串类型
    const wechatStr = String(homeInfo.wechat || "").trim();

    if (!wechatStr) {
      wx.showToast({
        title: "暂无微信号",
        icon: "none"
      });
      return;
    }

    wx.setClipboardData({
      data: wechatStr,
      success: () => {
        wx.showToast({
          title: "微信号已复制",
          icon: "success"
        });
      },
      fail: (err) => {
        console.error("复制微信号失败:", err);
        wx.showToast({
          title: "复制失败，请重试",
          icon: "none"
        });
      }
    });
  },

  /**
   * 复制手机号
   */
  copyPhone: function () {
    const homeInfo = this.data.homeInfo;

    if (!homeInfo || !homeInfo.phone) {
      wx.showToast({
        title: "暂无手机号",
        icon: "none"
      });
      return;
    }

    // 确保手机号是字符串类型
    const phoneStr = String(homeInfo.phone || "").trim();

    if (!phoneStr) {
      wx.showToast({
        title: "暂无手机号",
        icon: "none"
      });
      return;
    }

    wx.setClipboardData({
      data: phoneStr,
      success: () => {
        wx.showToast({
          title: "手机号已复制",
          icon: "success"
        });
      },
      fail: (err) => {
        console.error("复制手机号失败:", err);
        wx.showToast({
          title: "复制失败，请重试",
          icon: "none"
        });
      }
    });
  },

  /**
   * 加载拼房详情
   */
  loadRoomSharingDetail: function (id) {
    console.log("加载拼房详情:", id);

    // 显示加载提示
    wx.showLoading({
      title: "加载中..."
    });

    // 调用拼房详情API
    console.log("调用拼房详情接口，参数 id:", id);
    console.log("接口地址:", api.HomeInfo);

    util
      .request(
        api.HomeInfo,
        {
          id: parseInt(id)
        },
        "POST",
        "application/json"
      )
      .then((res) => {
        wx.hideLoading();

        console.log("拼房详情API响应:", res);

        // 标准化API响应
        const normalizedRes = util.normalizeApiResponse(res);
        console.log("标准化后的响应:", normalizedRes);

        if (normalizedRes.success && normalizedRes.data && normalizedRes.data) {
          // 确保data结构正确，使字段
          console.log("拼房详情homeInfo数据:", normalizedRes.data);
          // 更新页面数据
          this.updateRoomSharingDetailData(normalizedRes.data);
        } else {
          // API调用失败
          console.error("API返回数据格式错误:", normalizedRes);
          wx.showToast({
            title: normalizedRes.message || "加载失败",
            icon: "none",
            duration: 2000
          });

          // 使用模拟数据作为备选
          this.updateRoomSharingDetailDataWithId(id);
        }
      })
      .catch((err) => {
        wx.hideLoading();
        console.error("拼房详情API调用失败:", err);

        wx.showToast({
          title: "网络错误，请重试",
          icon: "none",
          duration: 2000
        });

        // 使用模拟数据作为备选
        this.updateRoomSharingDetailDataWithId(id);
      });
  },

  /**
   * 根据API响应数据更新拼房详情数据
   */
  updateRoomSharingDetailData: function (data) {
    console.log("更新拼房详情数据:", data);

    // 处理API返回的数据
    if (data && data) {
      const homeInfo = data;

      console.log("处理homeInfo数据:", homeInfo);

      // 格式化时间范围（入住时间-退房时间）
      let timeText = "";
      if (homeInfo.beginTime && homeInfo.endTime) {
        const beginTime = this.formatDate(homeInfo.beginTime);
        const endTime = this.formatDate(homeInfo.endTime);
        timeText = `${beginTime} - ${endTime}`;
      } else if (homeInfo.beginTime) {
        timeText = this.formatDate(homeInfo.beginTime);
      } else {
        timeText = "时间待定";
      }

      // 格式化房型文本
      const roomTypeText = this.getRoomTypeText(homeInfo.homeType);

      // 格式化性别文本
      const sexText = this.getSexText(homeInfo.sex);
      const limitSexText = this.getSexText(homeInfo.limitSex);

      // 处理住宿类型（ski字段是string类型）
      let accommodationType = "单房";
      if (homeInfo.ski) {
        const skiValue = String(homeInfo.ski);
        accommodationType = skiValue === "1" ? "住滑" : "单房";
      }

      // 计算时间间隔
      const duration = this.calculateDuration(
        homeInfo.beginTime,
        homeInfo.endTime
      );

      // 根据API响应格式更新页面数据
      // 处理地址显示：如果有locationName，分离主地址和详细地址
      const addressMain = homeInfo.address || "地址待定";
      const addressDetail = homeInfo.locationName || null;
      
      const roomInfo = {
        type: "拼房",
        serviceType: homeInfo.type === 0 ? "房找人" : "人找房",
        time: timeText,
        duration: duration, // 添加时间间隔
        address: addressMain,
        addressDetail: addressDetail,
        roomType: roomTypeText,
        sex: sexText,
        ski: homeInfo.ski,
        limitSex: limitSexText,
        price: `¥ ${homeInfo.price || 0}/人晚`,
        description: homeInfo.detail || "暂无详细描述",
        accommodationType: accommodationType, // 添加住宿类型信息（是否住滑）
        skiAddress: homeInfo.skiAddress || "" // 添加雪场地址
      };

      const userInfo = {
        nickName: homeInfo.nickName,
        imageUrl: homeInfo.imageUrl,
        skillIcons: [],
        badge: "https://static.codia.ai/image/2025-10-18/brc82VU2Ho.png"
      };

      const clubInfo = {
        icon: "https://static.codia.ai/image/2025-10-18/bgQwsUMpWh.png",
        text: homeInfo.isClub === 1 ? "俱乐部成员优先展示" : "普通用户"
      };

      // 更新页面数据
      this.setData({
        roomInfo: roomInfo,
        userInfo: userInfo,
        clubInfo: clubInfo,
        // 保存原始数据供其他功能使用（包括联系方式、地图坐标等）
        homeInfo: {
          wechat: homeInfo.wechat || "",
          phone: homeInfo.phone || "",
          type: homeInfo.type || 0,
          ski: homeInfo.ski || "0",
          homeType: homeInfo.homeType || 0,
          longitude: homeInfo.longitude || null,
          latitude: homeInfo.latitude || null,
          locationName: homeInfo.locationName || ""
        },
        // 判断是否有经纬度信息，用于控制样式和点击事件
        hasLocation: homeInfo.longitude && homeInfo.latitude ? true : false,
        // 从API返回的数据读取收藏状态
        isFavorited: homeInfo.isCollection === 1,
        // 保存isClub字段用于控制user-badge显示
        isClub: homeInfo.isClub || 0
      });

      console.log("拼房详情数据更新完成");

      // 数据加载完成后，预先生成分享卡片
      this.generateShareCard();
    } else {
      // 如果传入的是ID（兼容旧逻辑），使用模拟数据
      this.updateRoomSharingDetailDataWithId(data);
    }
  },

  /**
   * 根据ID更新拼房详情数据（模拟数据，用于兼容）
   */
  updateRoomSharingDetailDataWithId: function (id) {
    console.log("使用模拟数据更新拼房详情，ID:", id);

    // 模拟数据
    const mockData = {
      demo_001: {
        roomInfo: {
          type: "拼房",
          serviceType: "房找人",
          time: "后天 周六 10:00",
          address: "云顶大酒店",
          roomType: "标准间",
          sex: "不限",
          limitSex: "不限",
          price: "¥ 113/人",
          description: "寻找拼房伙伴，希望有共同爱好的朋友"
        }
      },
      demo_002: {
        roomInfo: {
          type: "拼房",
          serviceType: "人找房",
          time: "09.25 10:00",
          address: "云顶大酒店",
          roomType: "大床房",
          sex: "男",
          limitSex: "不限",
          price: "¥ 113/人",
          description: "寻找拼房，希望有经验丰富的室友"
        }
      }
    };

    const data = mockData[id] || mockData["demo_001"];

    this.setData({
      roomInfo: data.roomInfo
    });
  },

  /**
   * 获取房间类型文本
   */
  getRoomTypeText: function (type) {
    const typeMap = {
      0: "双床",
      1: "大床",
      2: "3人",
      3: "4人"
    };
    return typeMap[type] || "未知";
  },

  /**
   * 获取性别文本
   */
  getSexText: function (sex) {
    const sexMap = {
      0: "男",
      1: "女",
      2: "不限"
    };
    return sexMap[sex] || "不限";
  },

  /**
   * 显示风险须知弹窗
   */
  showRiskNoticePopup: function () {
    this.setData({
      showRiskNoticePopup: true
    });
  },

  /**
   * 隐藏风险须知弹窗
   */
  hideRiskNoticePopup: function () {
    this.setData({
      showRiskNoticePopup: false
    });
  },

  /**
   * 阻止弹窗内容区域点击事件冒泡
   */
  preventClose: function () {
    // 阻止事件冒泡，防止点击内容区域时关闭弹窗
  },

  /**
   * 确认风险须知
   */
  confirmRiskNotice: function () {
    this.setData({
      showRiskNoticePopup: false
    });
  },

  /**
   * 跳转到地图查看位置
   */
  openMapForLocation: function () {
    const homeInfo = this.data.homeInfo;

    if (!homeInfo) {
      return;
    }

    // 如果有经纬度信息，使用经纬度打开地图
    if (homeInfo.longitude && homeInfo.latitude) {
      wx.openLocation({
        latitude: parseFloat(homeInfo.latitude),
        longitude: parseFloat(homeInfo.longitude),
        name: this.data.roomInfo.address || "房间地址",
        address: homeInfo.locationName || this.data.roomInfo.address || "",
        success: () => {
          console.log("打开地图成功");
        },
        fail: (err) => {
          console.error("打开地图失败:", err);
          wx.showToast({
            title: "打开地图失败",
            icon: "none"
          });
        }
      });
    } else {
      // 如果没有经纬度，提示用户
      wx.showToast({
        title: "暂无位置信息",
        icon: "none"
      });
    }
  }
});
